home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume10 / xloadimage / patch2 next >
Encoding:
Internet Message Format  |  1990-12-16  |  66.8 KB
  1. Path: uunet!cs.utexas.edu!sun-barr!newstop!exodus!saber.com!jimf
  2. From: jimf@saber.com
  3. Newsgroups: comp.sources.x
  4. Subject: v10i092: xloadimage, Patch2, Part01/01
  5. Message-ID: <4593@exodus.Eng.Sun.COM>
  6. Date: 16 Dec 90 19:24:04 GMT
  7. References: <csx-10i092:xloadimage@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 2203
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: jimf@saber.com
  13. Posting-number: Volume 10, Issue 92
  14. Archive-name: xloadimage/patch2
  15. Patch-To: xloadimage: Volume 10, Issue 48-56, 64
  16.  
  17. This file contains a patch to bring xloadimage version 2.01 up to
  18. version 2.02.
  19.  
  20. Version 2.02 contains the following bug-fixes and enhancements:
  21.  
  22.     * low-level byte order conversion routines have been
  23.       macro-ized for the most common case for dramatic speed
  24.       improvements.
  25.     * -onroot is now compatible with xsetroot.
  26.     * Dithering and halftoning have been sped up somewhat.
  27.     * RLE files now load on MSBFirst machines.
  28.     * Window.c no longer double-paints in some circumstances.
  29.     * Some XWD files that loaded with the wrong colormap will now
  30.       load correctly.
  31.     * G3 FAX files now load and are differentiated from MacPaint
  32.       files.
  33.     * A bug where servers whose depths were not 1 or multiples of
  34.       8 bits would not load images which used the default colormap
  35.       was fixed.  If you had color problems under 2.x and not
  36.       under 1.6, this fixes the problem.
  37.     * The default gamma value was changed to 1.0 as documented.
  38.     * A simple normalization function, -normalize, was added.
  39.     * A grayscale conversion function, -gray, was added.
  40.     * An option to load the root weave, -default, was added.
  41.  
  42. Enjoy,
  43.  
  44. jim frost
  45. saber software
  46. jimf@saber.com
  47.  
  48. -- cut here --
  49. diff -c src.2.01/Makefile src.2.02/Makefile
  50. *** src.2.01/Makefile    Mon Oct  1 14:28:52 1990
  51. --- src.2.02/Makefile    Sat Dec  1 14:38:46 1990
  52. ***************
  53. *** 156,161 ****
  54. --- 156,167 ----
  55.       tar cf xloadimage.tar $(ALL)
  56.       rm Makefile.std
  57.   
  58. + # target for building debuggable versions
  59. + 
  60. + debug:
  61. +     @echo Building a debugging version of xloadimage.
  62. +     make xloadimage CC=$(STD_CC) CFLAGS="-g -DSYSPATHFILE=\\\"$(SYSPATHFILE)\\\""
  63. + 
  64.   # these targets are for those of us who have Saber-C
  65.   
  66.   # load all objects in saber.  useful if you then swap the portions to debug
  67. diff -c src.2.01/README src.2.02/README
  68. *** src.2.01/README    Sun Sep 30 19:08:48 1990
  69. --- src.2.02/README    Sun Dec  2 14:13:04 1990
  70. ***************
  71. *** 156,162 ****
  72.   (gwh@inmos.com) for a geometry patch, Glenn P. Davis
  73.   (davis@unidata.ucar.edu) for McIDAS areafile support, Keith S. Pickens
  74.   (maxwell.nde.swri.edu!ksp) for fixing the RLE loader to work with the
  75. ! updated zio package, and any others whose names I've missed.
  76.   
  77.   HISTORY
  78.   
  79. --- 156,164 ----
  80.   (gwh@inmos.com) for a geometry patch, Glenn P. Davis
  81.   (davis@unidata.ucar.edu) for McIDAS areafile support, Keith S. Pickens
  82.   (maxwell.nde.swri.edu!ksp) for fixing the RLE loader to work with the
  83. ! updated zio package, Mike Douglas (douglas@wilbur.coyote.trw.com) for
  84. ! normalization, Rod Johnson (johnson@wrl.epi.com) for speedup
  85. ! suggestions, and any others whose names I've missed.
  86.   
  87.   HISTORY
  88.   
  89. ***************
  90. *** 224,226 ****
  91. --- 226,245 ----
  92.   The gcc-1-37 make target was fixed to prevent a double-define.  The
  93.   GIF loader was patched to respond better to short GIF files.  The Utah
  94.   RLE image loader was patched to work with the updated ZIO package.
  95. + 
  96. + Version 2.02 added the options -default, -gray, -normalize, and
  97. + -private.  The memToVal routines were macro-ized for substantial speed
  98. + increases.  The atom used for deleting previously allocated colors for
  99. + the -onroot option was changed to correspond to that used by xsetroot.
  100. + Dithering and halftoning were changed to use a lookup table for
  101. + intensities to speed them up somewhat.  Rle.h was changed to use
  102. + memToValLSB() instead of its own byte-swapping algorithm for
  103. + portability.  Window.c was modified to eliminate the initial paint,
  104. + moving it instead to within ConfigureNotify.  A fix was made to xwd.c
  105. + to fix its colormap loader for out-of-order colormaps.  The G3 FAX
  106. + identification function was fixed and the G3 loader moved to prior to
  107. + the MacPaint loader so that both can be used.  A bug in send.c where
  108. + color images using the default colormap would not appear correctly if
  109. + the display depth was not a multiple of 8 was corrected.  The default
  110. + gamma value used in rle.c was changed from 2 to 1.  There were
  111. + miscellaneous portability changes.
  112. diff -c src.2.01/bright.c src.2.02/bright.c
  113. *** src.2.01/bright.c    Sun Sep 30 19:04:11 1990
  114. --- src.2.02/bright.c    Sun Dec  2 13:11:59 1990
  115. ***************
  116. *** 1,6 ****
  117.   /* bright.c
  118.    *
  119. !  * alter an image's brightness by a given percentage
  120.    *
  121.    * jim frost 10.10.89
  122.    *
  123. --- 1,6 ----
  124.   /* bright.c
  125.    *
  126. !  * miscellaneous colormap altering functions
  127.    *
  128.    * jim frost 10.10.89
  129.    *
  130. ***************
  131. *** 11,16 ****
  132. --- 11,19 ----
  133.   #include "copyright.h"
  134.   #include "image.h"
  135.   
  136. + /* alter an image's brightness by a given percentage
  137. +  */
  138. + 
  139.   void brighten(image, percent, verbose)
  140.        Image        *image;
  141.        unsigned int  percent;
  142. ***************
  143. *** 70,75 ****
  144. --- 73,166 ----
  145.       *(image->rgb.blue + a)= gammamap[(*(image->rgb.blue + a))>>8]<<8;
  146.     }
  147.   
  148. +   if (verbose)
  149. +     printf("done\n");
  150. + }
  151. + 
  152. + /* normalize an image.  this was originally written by Michael H. Douglas
  153. +  * to normalize into greyscale and modified by jim frost for color.
  154. +  */
  155. + 
  156. + void normalize(image, verbose)
  157. +      Image        *image;
  158. +      unsigned int  verbose;
  159. + { int          a;
  160. +   Intensity minintensity, maxintensity;
  161. +   float factor;
  162. + 
  163. +   if (! RGBP(image)) /* we're AT&T */
  164. +     return;
  165. + 
  166. +   compress(image, verbose);
  167. + 
  168. +   if (verbose) {
  169. +     printf("  Normalizing image...");
  170. +     fflush(stdout);
  171. +   }
  172. + 
  173. +   /* find range of intensities
  174. +    */
  175. + 
  176. +   maxintensity = 0;
  177. +   minintensity = 65536;
  178. +   for (a= 0; a < image->rgb.used; a++) {
  179. +     if (image->rgb.red[a] > maxintensity)
  180. +       maxintensity = image->rgb.red[a];
  181. +     if (image->rgb.red[a] < minintensity)
  182. +       minintensity= image->rgb.red[a];
  183. +     if (image->rgb.green[a] > maxintensity)
  184. +       maxintensity = image->rgb.green[a];
  185. +     if (image->rgb.green[a] < minintensity)
  186. +       minintensity= image->rgb.green[a];
  187. +     if (image->rgb.blue[a] > maxintensity)
  188. +       maxintensity = image->rgb.blue[a];
  189. +     if (image->rgb.blue[a] < minintensity)
  190. +       minintensity= image->rgb.blue[a];
  191. +   }
  192. + 
  193. +   printf("remapping from %d:%d to 0:65535...", minintensity, maxintensity);
  194. +   fflush(stdout);
  195. +   factor= 65535.0 / (maxintensity - minintensity);
  196. +   for (a= 0; a < image->rgb.used; a++) {
  197. +     image->rgb.red[a]= (float)(image->rgb.red[a] - minintensity) * factor;
  198. +     image->rgb.green[a]= (float)(image->rgb.green[a] - minintensity) * factor;
  199. +     image->rgb.blue[a]= (float)(image->rgb.blue[a] - minintensity) * factor;
  200. + #if 0
  201. +     newrgb = *(image->rgb.red + a);
  202. +     newrgb = ( newrgb - minrgb ) * 65535 / range;
  203. +     *(image->rgb.red + a)= newrgb;
  204. +     *(image->rgb.green + a)= newrgb;
  205. +     *(image->rgb.blue + a)= newrgb;
  206. + #endif
  207. +   }
  208. + 
  209. +   if (verbose)
  210. +     printf("done\n");
  211. + }
  212. + 
  213. + /* convert to grayscale
  214. +  */
  215. + 
  216. + void gray(image, verbose)
  217. +      Image *image;
  218. + { int a;
  219. +   Intensity intensity;
  220. + 
  221. +   if (!RGBP(image))
  222. +     return;
  223. + 
  224. +   if (verbose) {
  225. +     printf("  Converting image to grayscale...");
  226. +     fflush(stdout);
  227. +   }
  228. +   for (a= 0; a < image->rgb.used; a++) {
  229. +     intensity= colorIntensity(image->rgb.red[a],
  230. +                   image->rgb.green[a],
  231. +                   image->rgb.blue[a]);
  232. +     image->rgb.red[a]= intensity;
  233. +     image->rgb.green[a]= intensity;
  234. +     image->rgb.blue[a]= intensity;
  235. +   }
  236.     if (verbose)
  237.       printf("done\n");
  238.   }
  239. diff -c src.2.01/compress.c src.2.02/compress.c
  240. *** src.2.01/compress.c    Sun Sep 30 19:04:12 1990
  241. --- src.2.02/compress.c    Sun Dec  2 13:50:51 1990
  242. ***************
  243. *** 18,28 ****
  244.     unsigned int *used;  
  245.     RGBMap        rgb;
  246.     byte         *pixptr, *pixptr2;
  247. !   unsigned int  a, x, y;
  248.     Pixel         color, newpixlen;
  249.   
  250.     goodImage(image, "compress");
  251. !   if (! RGBP(image)) /* we're AT&T */
  252.       return;
  253.   
  254.     if (verbose) {
  255. --- 18,28 ----
  256.     unsigned int *used;  
  257.     RGBMap        rgb;
  258.     byte         *pixptr, *pixptr2;
  259. !   unsigned int  a, x, y, depth;
  260.     Pixel         color, newpixlen;
  261.   
  262.     goodImage(image, "compress");
  263. !   if (!RGBP(image) || image->rgb.compressed) /* we're AT&T */
  264.       return;
  265.   
  266.     if (verbose) {
  267. ***************
  268. *** 68,90 ****
  269.     freeRGBMapData(&(image->rgb));
  270.     image->rgb= rgb;
  271.   
  272. ! /* Okay, we've compressed the colors, let's do the image */
  273. !   for (y=0,x=1;rgb.used>x;y++) x=x*2;
  274. !   newpixlen = (y / 8) + (y % 8 ? 1 : 0);
  275. !   if (newpixlen < image->pixlen)
  276. !   {
  277. !     if (verbose)
  278. !         printf("  Compressing image...");fflush(stdout);
  279. !     pixptr = image->data; pixptr2 = image->data;
  280. !     for (y= 0; y < image->height; y++)
  281. !      for (x= 0; x < image->width; x++) {
  282. !         valToMem(memToVal(pixptr2,image->pixlen), pixptr, newpixlen);
  283. !         pixptr2 += image->pixlen;
  284. !         pixptr += newpixlen;
  285. !      }
  286. !     image->pixlen = newpixlen;
  287. !     if (verbose)
  288. !         printf("done\n");
  289. !    }
  290.   
  291.   }
  292. --- 68,94 ----
  293.     freeRGBMapData(&(image->rgb));
  294.     image->rgb= rgb;
  295.   
  296. !   /* Okay, we've compressed the colors, let's do the image
  297. !    */
  298.   
  299. +   for (depth=0, x=1; rgb.used > x ; depth++)
  300. +     x= x * 2;
  301. +   newpixlen = (depth / 8) + (depth % 8 ? 1 : 0);
  302. +   if (newpixlen < image->pixlen) {
  303. +     if (verbose)
  304. +       printf("  Compressing image...");fflush(stdout);
  305. +     pixptr = image->data; pixptr2 = image->data;
  306. +     for (y= 0; y < image->height; y++)
  307. +       for (x= 0; x < image->width; x++) {
  308. +     valToMem(memToVal(pixptr2,image->pixlen), pixptr, newpixlen);
  309. +     pixptr2 += image->pixlen;
  310. +     pixptr += newpixlen;
  311. +       }
  312. +     image->pixlen = newpixlen;
  313. +     image->depth= depth;
  314. +     if (verbose)
  315. +       printf("done\n");
  316. +   }
  317. + 
  318. +   image->rgb.compressed= 1;
  319.   }
  320. diff -c src.2.01/copyright.h src.2.02/copyright.h
  321. *** src.2.01/copyright.h    Sun Sep 30 19:04:28 1990
  322. --- src.2.02/copyright.h    Sat Dec  1 14:26:19 1990
  323. ***************
  324. *** 19,24 ****
  325. --- 19,26 ----
  326.    * USE OR PERFORMANCE OF THIS SOFTWARE.
  327.    */
  328.   
  329. + #ifndef __SABER__
  330.   static char *Copyright= "Copyright 1989, 1990 Jim Frost";
  331. + #endif
  332.   #define _JIM_COPYRIGHT_
  333.   #endif
  334. diff -c src.2.01/dither.c src.2.02/dither.c
  335. *** src.2.01/dither.c    Sun Sep 30 19:04:12 1990
  336. --- src.2.02/dither.c    Wed Oct  3 12:06:28 1990
  337. ***************
  338. *** 22,31 ****
  339.   #include "kljcpyrght.h"
  340.   #include "image.h"
  341.   
  342. - #define RedPercent  0.299
  343. - #define GrnPercent  0.587    /* color -> grey conversion parameters */
  344. - #define BluPercent  0.114
  345. - 
  346.   #define MaxIntensity  65536    /* maximum possible Intensity */
  347.   
  348.   #define MaxGrey       32768    /* limits on the grey levels used */
  349. --- 22,27 ----
  350. ***************
  351. *** 90,103 ****
  352.     {
  353.       grey = (unsigned int *)lmalloc(sizeof(unsigned int) * cimage->rgb.used);
  354.       for (i=0; i<cimage->rgb.used; i++)
  355. !     {
  356. !       tmp  = (cimage->rgb.red[i]   * RedPercent);
  357. !       tmp += (cimage->rgb.green[i] * GrnPercent);
  358. !       tmp += (cimage->rgb.blue[i]  * BluPercent);
  359.   
  360. -       grey[i] = (tmp / MaxIntensity) * MaxGrey;
  361. -     }
  362. - 
  363.       for (i=0; i<cimage->rgb.used; i++)
  364.         grey[i] = tone_scale_adjust(grey[i]);
  365.     }
  366. --- 86,96 ----
  367.     {
  368.       grey = (unsigned int *)lmalloc(sizeof(unsigned int) * cimage->rgb.used);
  369.       for (i=0; i<cimage->rgb.used; i++)
  370. !       grey[i]=
  371. !     (colorIntensity(cimage->rgb.red[i],
  372. !             cimage->rgb.green[i],
  373. !             cimage->rgb.blue[i]) >> 1);
  374.   
  375.       for (i=0; i<cimage->rgb.used; i++)
  376.         grey[i] = tone_scale_adjust(grey[i]);
  377.     }
  378. ***************
  379. *** 136,152 ****
  380.         src  += spl;
  381.         
  382.         if (grey == NULL)
  383. !       {
  384. !     tmp  = (cimage->rgb.red[color]   * RedPercent);
  385. !     tmp += (cimage->rgb.green[color] * GrnPercent);
  386. !     tmp += (cimage->rgb.blue[color]  * BluPercent);
  387. ! 
  388. !     level = tone_scale_adjust((tmp / MaxIntensity) * MaxGrey);
  389. !       }
  390.         else
  391. -       {
  392.       level = grey[color];
  393. -       }
  394.   
  395.         curr[j] += level;
  396.       }
  397. --- 129,140 ----
  398.         src  += spl;
  399.         
  400.         if (grey == NULL)
  401. !     level =
  402. !       tone_scale_adjust(colorIntensity(cimage->rgb.red[color],
  403. !                        cimage->rgb.green[color],
  404. !                        cimage->rgb.blue[color]) >> 1);
  405.         else
  406.       level = grey[color];
  407.   
  408.         curr[j] += level;
  409.       }
  410. diff -c src.2.01/g3.c src.2.02/g3.c
  411. *** src.2.01/g3.c    Sun Sep 30 19:04:28 1990
  412. --- src.2.02/g3.c    Sat Dec  1 20:00:01 1990
  413. ***************
  414. *** 35,40 ****
  415. --- 35,41 ----
  416.   int g3_eof = 0;
  417.   int g3_eols;
  418.   int g3_rawzeros;
  419. + int g3_Xrawzeros;
  420.   int    maxlinelen;
  421.   int    rows, cols;
  422.   
  423. ***************
  424. *** 236,241 ****
  425. --- 237,243 ----
  426.           curbit = 0;
  427.           }
  428.       if (shdata & bmask[curbit]) {
  429. +         g3_Xrawzeros = g3_rawzeros;
  430.           g3_rawzeros = 0;
  431.           b = 1;
  432.           }
  433. ***************
  434. *** 280,286 ****
  435.       int    ret = 0;
  436.   
  437.       for (g3_rawzeros = 0; !g3_rawgetbit(fd) && !g3_eof;);
  438. !     if(g3_rawzeros >=11 && g3_rawzeros <= 15)
  439.           ret = 1;
  440.   
  441.       return(ret);
  442. --- 282,288 ----
  443.       int    ret = 0;
  444.   
  445.       for (g3_rawzeros = 0; !g3_rawgetbit(fd) && !g3_eof;);
  446. !     if(g3_Xrawzeros >=11 && g3_Xrawzeros <= 15)
  447.           ret = 1;
  448.   
  449.       return(ret);
  450. ***************
  451. *** 350,356 ****
  452.       }
  453.   
  454.       if(verbose)
  455. !         printf("  %s is a %dx%d G3 FAX image.\n", image->width, image->height);
  456.       return(image);
  457.   }
  458.   
  459. --- 352,358 ----
  460.       }
  461.   
  462.       if(verbose)
  463. !         printf("  %s is a %dx%d G3 FAX image.\n", name, image->width, image->height);
  464.       return(image);
  465.   }
  466.   
  467. diff -c src.2.01/halftone.c src.2.02/halftone.c
  468. *** src.2.01/halftone.c    Sun Sep 30 19:04:12 1990
  469. --- src.2.02/halftone.c    Wed Oct  3 12:01:07 1990
  470. ***************
  471. *** 13,23 ****
  472.   #include "copyright.h"
  473.   #include "image.h"
  474.   
  475.   /* 4x4 arrays used for dithering, arranged by nybble
  476.    */
  477.   
  478.   #define GRAYS    17 /* ((4 * 4) + 1) patterns for a good dither */
  479. ! #define GRAYSTEP ((unsigned long)(65536 * 3) / GRAYS)
  480.   
  481.   static byte DitherBits[GRAYS][4] = {
  482.     0xf, 0xf, 0xf, 0xf,
  483. --- 13,133 ----
  484.   #include "copyright.h"
  485.   #include "image.h"
  486.   
  487. + /* RGB intensity tables.  red is (val * 0.30), green is (val * 0.59), blue
  488. +  * is (val * .11), where val is intensity >> 8.  these are used by the
  489. +  * colorIntensity() macro in images.h.
  490. +  */
  491. + 
  492. + unsigned short RedIntensity[256]= {
  493. +       0,    76,   153,   230,   307,   384,   460,   537,
  494. +     614,   691,   768,   844,   921,   998,  1075,  1152,
  495. +    1228,  1305,  1382,  1459,  1536,  1612,  1689,  1766,
  496. +    1843,  1920,  1996,  2073,  2150,  2227,  2304,  2380,
  497. +    2457,  2534,  2611,  2688,  2764,  2841,  2918,  2995,
  498. +    3072,  3148,  3225,  3302,  3379,  3456,  3532,  3609,
  499. +    3686,  3763,  3840,  3916,  3993,  4070,  4147,  4224,
  500. +    4300,  4377,  4454,  4531,  4608,  4684,  4761,  4838,
  501. +    4915,  4992,  5068,  5145,  5222,  5299,  5376,  5452,
  502. +    5529,  5606,  5683,  5760,  5836,  5913,  5990,  6067,
  503. +    6144,  6220,  6297,  6374,  6451,  6528,  6604,  6681,
  504. +    6758,  6835,  6912,  6988,  7065,  7142,  7219,  7296,
  505. +    7372,  7449,  7526,  7603,  7680,  7756,  7833,  7910,
  506. +    7987,  8064,  8140,  8217,  8294,  8371,  8448,  8524,
  507. +    8601,  8678,  8755,  8832,  8908,  8985,  9062,  9139,
  508. +    9216,  9292,  9369,  9446,  9523,  9600,  9676,  9753,
  509. +    9830,  9907,  9984, 10060, 10137, 10214, 10291, 10368,
  510. +   10444, 10521, 10598, 10675, 10752, 10828, 10905, 10982,
  511. +   11059, 11136, 11212, 11289, 11366, 11443, 11520, 11596,
  512. +   11673, 11750, 11827, 11904, 11980, 12057, 12134, 12211,
  513. +   12288, 12364, 12441, 12518, 12595, 12672, 12748, 12825,
  514. +   12902, 12979, 13056, 13132, 13209, 13286, 13363, 13440,
  515. +   13516, 13593, 13670, 13747, 13824, 13900, 13977, 14054,
  516. +   14131, 14208, 14284, 14361, 14438, 14515, 14592, 14668,
  517. +   14745, 14822, 14899, 14976, 15052, 15129, 15206, 15283,
  518. +   15360, 15436, 15513, 15590, 15667, 15744, 15820, 15897,
  519. +   15974, 16051, 16128, 16204, 16281, 16358, 16435, 16512,
  520. +   16588, 16665, 16742, 16819, 16896, 16972, 17049, 17126,
  521. +   17203, 17280, 17356, 17433, 17510, 17587, 17664, 17740,
  522. +   17817, 17894, 17971, 18048, 18124, 18201, 18278, 18355,
  523. +   18432, 18508, 18585, 18662, 18739, 18816, 18892, 18969,
  524. +   19046, 19123, 19200, 19276, 19353, 19430, 19507, 19584
  525. + };
  526. + 
  527. + unsigned short GreenIntensity[256]= {
  528. +      0,  151,  302,  453,  604,  755,  906, 1057,
  529. +   1208, 1359, 1510, 1661, 1812, 1963, 2114, 2265,
  530. +   2416, 2567, 2718, 2869, 3020, 3171, 3322, 3473,
  531. +   3624, 3776, 3927, 4078, 4229, 4380, 4531, 4682,
  532. +   4833, 4984, 5135, 5286, 5437, 5588, 5739, 5890,
  533. +   6041, 6192, 6343, 6494, 6645, 6796, 6947, 7098,
  534. +   7249, 7400, 7552, 7703, 7854, 8005, 8156, 8307,
  535. +   8458, 8609, 8760, 8911, 9062, 9213, 9364, 9515,
  536. +   9666, 9817, 9968,10119,10270,10421,10572,10723,
  537. +  10874,11025,11176,11328,11479,11630,11781,11932,
  538. +  12083,12234,12385,12536,12687,12838,12989,13140,
  539. +  13291,13442,13593,13744,13895,14046,14197,14348,
  540. +  14499,14650,14801,14952,15104,15255,15406,15557,
  541. +  15708,15859,16010,16161,16312,16463,16614,16765,
  542. +  16916,17067,17218,17369,17520,17671,17822,17973,
  543. +  18124,18275,18426,18577,18728,18880,19031,19182,
  544. +  19333,19484,19635,19786,19937,20088,20239,20390,
  545. +  20541,20692,20843,20994,21145,21296,21447,21598,
  546. +  21749,21900,22051,22202,22353,22504,22656,22807,
  547. +  22958,23109,23260,23411,23562,23713,23864,24015,
  548. +  24166,24317,24468,24619,24770,24921,25072,25223,
  549. +  25374,25525,25676,25827,25978,26129,26280,26432,
  550. +  26583,26734,26885,27036,27187,27338,27489,27640,
  551. +  27791,27942,28093,28244,28395,28546,28697,28848,
  552. +  28999,29150,29301,29452,29603,29754,29905,30056,
  553. +  30208,30359,30510,30661,30812,30963,31114,31265,
  554. +  31416,31567,31718,31869,32020,32171,32322,32473,
  555. +  32624,32775,32926,33077,33228,33379,33530,33681,
  556. +  33832,33984,34135,34286,34437,34588,34739,34890,
  557. +  35041,35192,35343,35494,35645,35796,35947,36098,
  558. +  36249,36400,36551,36702,36853,37004,37155,37306,
  559. +  37457,37608,37760,37911,38062,38213,38364,38515
  560. + };
  561. + 
  562. + unsigned short BlueIntensity[256]= {
  563. +      0,   28,   56,   84,  112,  140,  168,  197,
  564. +    225,  253,  281,  309,  337,  366,  394,  422,
  565. +    450,  478,  506,  535,  563,  591,  619,  647,
  566. +    675,  704,  732,  760,  788,  816,  844,  872,
  567. +    901,  929,  957,  985, 1013, 1041, 1070, 1098,
  568. +   1126, 1154, 1182, 1210, 1239, 1267, 1295, 1323,
  569. +   1351, 1379, 1408, 1436, 1464, 1492, 1520, 1548,
  570. +   1576, 1605, 1633, 1661, 1689, 1717, 1745, 1774,
  571. +   1802, 1830, 1858, 1886, 1914, 1943, 1971, 1999,
  572. +   2027, 2055, 2083, 2112, 2140, 2168, 2196, 2224,
  573. +   2252, 2280, 2309, 2337, 2365, 2393, 2421, 2449,
  574. +   2478, 2506, 2534, 2562, 2590, 2618, 2647, 2675,
  575. +   2703, 2731, 2759, 2787, 2816, 2844, 2872, 2900,
  576. +   2928, 2956, 2984, 3013, 3041, 3069, 3097, 3125,
  577. +   3153, 3182, 3210, 3238, 3266, 3294, 3322, 3351,
  578. +   3379, 3407, 3435, 3463, 3491, 3520, 3548, 3576,
  579. +   3604, 3632, 3660, 3688, 3717, 3745, 3773, 3801,
  580. +   3829, 3857, 3886, 3914, 3942, 3970, 3998, 4026,
  581. +   4055, 4083, 4111, 4139, 4167, 4195, 4224, 4252,
  582. +   4280, 4308, 4336, 4364, 4392, 4421, 4449, 4477,
  583. +   4505, 4533, 4561, 4590, 4618, 4646, 4674, 4702,
  584. +   4730, 4759, 4787, 4815, 4843, 4871, 4899, 4928,
  585. +   4956, 4984, 5012, 5040, 5068, 5096, 5125, 5153,
  586. +   5181, 5209, 5237, 5265, 5294, 5322, 5350, 5378,
  587. +   5406, 5434, 5463, 5491, 5519, 5547, 5575, 5603,
  588. +   5632, 5660, 5688, 5716, 5744, 5772, 5800, 5829,
  589. +   5857, 5885, 5913, 5941, 5969, 5998, 6026, 6054,
  590. +   6082, 6110, 6138, 6167, 6195, 6223, 6251, 6279,
  591. +   6307, 6336, 6364, 6392, 6420, 6448, 6476, 6504,
  592. +   6533, 6561, 6589, 6617, 6645, 6673, 6702, 6730,
  593. +   6758, 6786, 6814, 6842, 6871, 6899, 6927, 6955,
  594. +   6983, 7011, 7040, 7068, 7096, 7124, 7152, 7180
  595. + };
  596. + 
  597.   /* 4x4 arrays used for dithering, arranged by nybble
  598.    */
  599.   
  600.   #define GRAYS    17 /* ((4 * 4) + 1) patterns for a good dither */
  601. ! #define GRAYSTEP ((unsigned long)(65536 / GRAYS))
  602.   
  603.   static byte DitherBits[GRAYS][4] = {
  604.     0xf, 0xf, 0xf, 0xf,
  605. ***************
  606. *** 85,93 ****
  607.       index= (unsigned int *)lmalloc(sizeof(unsigned int) * cimage->rgb.used);
  608.       for (x= 0; x < cimage->rgb.used; x++) {
  609.         *(index + x)=
  610. !     ((unsigned long)(*(cimage->rgb.red + x)) +
  611. !      *(cimage->rgb.green + x) +
  612. !      *(cimage->rgb.blue + x)) / GRAYSTEP;
  613.         if (*(index + x) >= GRAYS) /* rounding errors can do this */
  614.       *(index + x)= GRAYS - 1;
  615.       }
  616. --- 195,203 ----
  617.       index= (unsigned int *)lmalloc(sizeof(unsigned int) * cimage->rgb.used);
  618.       for (x= 0; x < cimage->rgb.used; x++) {
  619.         *(index + x)=
  620. !     ((unsigned long)colorIntensity(*(cimage->rgb.red + x),
  621. !                        *(cimage->rgb.green + x),
  622. !                        *(cimage->rgb.blue + x))) / GRAYSTEP;
  623.         if (*(index + x) >= GRAYS) /* rounding errors can do this */
  624.       *(index + x)= GRAYS - 1;
  625.       }
  626. ***************
  627. *** 107,115 ****
  628.         if (index)
  629.       dindex= *(index + color);
  630.         else {
  631. !     dindex= ((unsigned long)(*(cimage->rgb.red + color)) +
  632. !          *(cimage->rgb.green + color) +
  633. !          *(cimage->rgb.blue + color)) / GRAYSTEP;
  634.       if (dindex >= GRAYS) /* rounding errors can do this */
  635.         dindex= GRAYS - 1;
  636.         }
  637. --- 217,226 ----
  638.         if (index)
  639.       dindex= *(index + color);
  640.         else {
  641. !     dindex= 
  642. !       ((unsigned long)colorIntensity(*(cimage->rgb.red + x),
  643. !                      *(cimage->rgb.green + x),
  644. !                      *(cimage->rgb.blue + x))) / GRAYSTEP;
  645.       if (dindex >= GRAYS) /* rounding errors can do this */
  646.         dindex= GRAYS - 1;
  647.         }
  648. diff -c src.2.01/image.h src.2.02/image.h
  649. *** src.2.01/image.h    Sun Sep 30 19:04:29 1990
  650. --- src.2.02/image.h    Sun Dec  2 12:21:16 1990
  651. ***************
  652. *** 35,43 ****
  653.   #define ZSTDIN    2 /* file is stdin */
  654.   
  655.   typedef struct rgbmap {
  656. !   unsigned int  size;  /* size of RGB map */
  657. !   unsigned int  used;  /* number of colors used in RGB map */
  658. !   Intensity    *red;   /* color values in X style */
  659.     Intensity    *green;
  660.     Intensity    *blue;
  661.   } RGBMap;
  662. --- 35,44 ----
  663.   #define ZSTDIN    2 /* file is stdin */
  664.   
  665.   typedef struct rgbmap {
  666. !   unsigned int  size;       /* size of RGB map */
  667. !   unsigned int  used;       /* number of colors used in RGB map */
  668. !   unsigned int  compressed; /* image uses colormap fully */
  669. !   Intensity    *red;        /* color values in X style */
  670.     Intensity    *green;
  671.     Intensity    *blue;
  672.   } RGBMap;
  673. ***************
  674. *** 62,67 ****
  675. --- 63,82 ----
  676.   #define BITMAPP(IMAGE) ((IMAGE)->type == IBITMAP)
  677.   #define RGBP(IMAGE)    ((IMAGE)->type == IRGB)
  678.   
  679. + /* special case 1-byte transfers so they're inline
  680. +  */
  681. + 
  682. + #define memToVal(PTR,LEN)    ((LEN) == 1 ? (unsigned long)(*(PTR)) : \
  683. +                   doMemToVal(PTR,LEN))
  684. + #define memToValLSB(PTR,LEN) ((LEN) == 1 ? (unsigned long)(*(PTR)) : \
  685. +                   doMemToValLSB(PTR,LEN))
  686. + #define valToMem(VAL,PTR,LEN)    ((LEN) == 1 ? \
  687. +                   (unsigned long)(*(PTR) = (byte)(VAL)) : \
  688. +                   doValToMem(VAL,PTR,LEN))
  689. + #define valToMemLSB(VAL,PTR,LEN) ((LEN) == 1 ? \
  690. +                   (unsigned long)(*(PTR) = (byte)(VAL)) : \
  691. +                   (int)doValToMemLSB(VAL,PTR,LEN))
  692. + 
  693.   /* function declarations
  694.    */
  695.   
  696. ***************
  697. *** 68,73 ****
  698. --- 83,91 ----
  699.   Image *clip(); /* clip.c */
  700.   
  701.   void brighten(); /* bright.c */
  702. + void equalize();
  703. + void gray();
  704. + void normalize();
  705.   
  706.   void compress(); /* compress.c */
  707.   
  708. ***************
  709. *** 105,115 ****
  710.   void reduceRGBMap(); /* reduce.c */
  711.   void reduce();
  712.   
  713. ! unsigned long memToVal(); /* value.c */
  714. ! void          valToMem();
  715. ! unsigned long memToValLSB();
  716. ! void          valToMemLSB();
  717.   
  718.   Image *zoom(); /* zoom.c */
  719.   Image *rotate(); /* rotate.c */
  720.   Image *smooth(); /* smooth.c */
  721. --- 123,148 ----
  722.   void reduceRGBMap(); /* reduce.c */
  723.   void reduce();
  724.   
  725. ! /* doMemToVal and doMemToValLSB used to be void type but some compilers
  726. !  * (particularly the 4.1.1 SunOS compiler) couldn't handle the
  727. !  * (void)(thing= value) conversion used in the macros.
  728. !  */
  729.   
  730. + unsigned long doMemToVal(); /* value.c */
  731. + unsigned long doValToMem();
  732. + unsigned long doMemToValLSB();
  733. + unsigned long doValToMemLSB();
  734. + 
  735.   Image *zoom(); /* zoom.c */
  736.   Image *rotate(); /* rotate.c */
  737.   Image *smooth(); /* smooth.c */
  738. + 
  739. + /* this returns the (approximate) intensity of an RGB triple
  740. +  */
  741. + 
  742. + #define colorIntensity(R,G,B) \
  743. +   (RedIntensity[(R) >> 8] + GreenIntensity[(G) >> 8] + BlueIntensity[(B) >> 8])
  744. + 
  745. + extern unsigned short RedIntensity[];
  746. + extern unsigned short GreenIntensity[];
  747. + extern unsigned short BlueIntensity[];
  748. diff -c src.2.01/imagetypes.h src.2.02/imagetypes.h
  749. *** src.2.01/imagetypes.h    Sun Sep 30 19:04:29 1990
  750. --- src.2.02/imagetypes.h    Sat Dec  1 20:02:53 1990
  751. ***************
  752. *** 52,60 ****
  753.     rleIdent,       rleLoad,       "Utah RLE Image",
  754.     xwdIdent,       xwdLoad,       "X Window Dump",
  755.     mcidasIdent,    mcidasLoad,    "McIDAS areafile",
  756.     macIdent,       macLoad,       "MacPaint Image",
  757.     xpixmapIdent,   xpixmapLoad,   "X Pixmap",
  758.     xbitmapIdent,   xbitmapLoad,   "X Bitmap",
  759. -   g3Ident,        g3Load,        "G3 FAX Image",
  760.     NULL,           NULL,          NULL
  761.   };
  762. --- 52,60 ----
  763.     rleIdent,       rleLoad,       "Utah RLE Image",
  764.     xwdIdent,       xwdLoad,       "X Window Dump",
  765.     mcidasIdent,    mcidasLoad,    "McIDAS areafile",
  766. +   g3Ident,        g3Load,        "G3 FAX Image",
  767.     macIdent,       macLoad,       "MacPaint Image",
  768.     xpixmapIdent,   xpixmapLoad,   "X Pixmap",
  769.     xbitmapIdent,   xbitmapLoad,   "X Bitmap",
  770.     NULL,           NULL,          NULL
  771.   };
  772. diff -c src.2.01/kljcpyrght.h src.2.02/kljcpyrght.h
  773. *** src.2.01/kljcpyrght.h    Sun Sep 30 19:04:13 1990
  774. --- src.2.02/kljcpyrght.h    Sat Dec  1 14:26:38 1990
  775. ***************
  776. *** 21,26 ****
  777. --- 21,28 ----
  778.     CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  779.   ****/
  780.   
  781. + #ifndef __SABER__
  782.   static char *KLJCopyright = "Copyright 1989, 1990 Kirk L. Johnson";
  783. + #endif
  784.   #define _KLJ_COPYRIGHT_
  785.   #endif
  786. diff -c src.2.01/mac.c src.2.02/mac.c
  787. *** src.2.01/mac.c    Sun Sep 30 19:04:13 1990
  788. --- src.2.02/mac.c    Sat Dec  1 20:05:17 1990
  789. ***************
  790. *** 73,85 ****
  791.     if (zread(ins, hp, ADD_HDR_LEN) != ADD_HDR_LEN)
  792.       return MACIN_ERR_EOF;
  793.   
  794. !   /*
  795. !    * if mhsum = 0 this is probably a
  796. !    * a g3 fax file.
  797. !    */
  798. !   for (i = 0; i < 10; i++) mhsum += mhdr[1];
  799. ! 
  800. !   if (mhdr[0] != MAC_MAGIC && mhsum != 0)
  801.       return MACIN_ERR_BAD_SD;
  802.   
  803.     /* Get image name  (if available) */
  804. --- 73,79 ----
  805.     if (zread(ins, hp, ADD_HDR_LEN) != ADD_HDR_LEN)
  806.       return MACIN_ERR_EOF;
  807.   
  808. !   if (mhdr[0] != MAC_MAGIC)
  809.       return MACIN_ERR_BAD_SD;
  810.   
  811.     /* Get image name  (if available) */
  812. diff -c src.2.01/mc_tables.c src.2.02/mc_tables.c
  813. *** src.2.01/mc_tables.c    Sun Sep 30 19:04:34 1990
  814. --- src.2.02/mc_tables.c    Sun Dec  2 14:17:20 1990
  815. ***************
  816. *** 1,5 ****
  817. - /* $Id: mc_tables.c,v 1.1 89/10/16 16:27:48 davis Exp $ */
  818. - 
  819.   /*
  820.    *  From McIDAS Reference Manual
  821.    *     Introduction - pg 21
  822. --- 1,3 ----
  823. diff -c src.2.01/mcidas.h src.2.02/mcidas.h
  824. *** src.2.01/mcidas.h    Sun Sep 30 19:04:35 1990
  825. --- src.2.02/mcidas.h    Sun Dec  2 14:17:54 1990
  826. ***************
  827. *** 1,4 ****
  828. ! /*    $Id: mcidas.h,v 1.1 90/09/28 20:26:36 davis Exp $ */
  829.   
  830.   /* Argh, looks like the numbers are in vax byte order */
  831.   
  832. --- 1,5 ----
  833. ! /* mcidas.h
  834. !  */
  835.   
  836.   /* Argh, looks like the numbers are in vax byte order */
  837.   
  838. ***************
  839. *** 69,73 ****
  840.       struct area_dir *dir ;
  841.       struct navigation *nav ;
  842.       unsigned char *image ;
  843. !     unsigned char *private ; /* conveninence pointer */
  844.   } ;
  845. --- 70,74 ----
  846.       struct area_dir *dir ;
  847.       struct navigation *nav ;
  848.       unsigned char *image ;
  849. !     unsigned char *priv ; /* conveninence pointer */
  850.   } ;
  851. diff -c src.2.01/misc.c src.2.02/misc.c
  852. *** src.2.01/misc.c    Sun Sep 30 19:04:13 1990
  853. --- src.2.02/misc.c    Sun Dec  2 14:05:55 1990
  854. ***************
  855. *** 19,24 ****
  856. --- 19,25 ----
  857.     printf("Global options:\n");
  858.     printf("  -onroot               - load image onto root window\n");
  859.     printf("  -border colorname     - border image with this color\n");
  860. +   printf("  -default              - set root window to default pattern\n");
  861.     printf("  -display dispname     - destination display\n");
  862.     printf("  -fullscreen           - use entire screen for display\n");
  863.     printf("  -geometry WxH+X+Y     - destination size and location\n");
  864. ***************
  865. *** 27,32 ****
  866. --- 28,34 ----
  867.     printf("  -list                 - list images in path\n");
  868.     printf("  -install              - explicitly install colormap\n");
  869.     printf("  -path                 - show image path for loading\n");
  870. +   printf("  -private              - force allocation of private colormap\n");
  871.     printf("  -quiet                - silence is golden\n");
  872.     printf("  -slideshow            - show images in slideshow style\n");
  873.     printf("  -supported            - show supported image types\n");
  874. ***************
  875. *** 36,51 ****
  876.     printf("Image_options:\n");
  877.     printf("  -at X,Y               - load image at location\n");
  878.     printf("  -background colorname - background color for bitmap images\n");
  879. -   printf("  -gamma display_gamma  - specify display gamma - default = 1.0\n");
  880.     printf("                        - typical display needs 2.0 - 2.5\n");
  881.     printf("  -brighten percentage  - specify brightness multiplier\n");
  882.     printf("  -center               - center image\n");
  883. -   printf("  -colors number        - specify maximum number of RGB colors\n");
  884.     printf("  -clip X,Y,W,H         - use clipped portion of image\n");
  885.     printf("  -dither               - dither color image to bitmap image\n");
  886.     printf("  -foreground colorname - foreground color for bitmap images\n");
  887.     printf("  -halftone             - halftone a color image to bitmap image\n");
  888.     printf("  -name name            - force next argument to be image name\n");
  889.     printf("  -rotate degrees       - rotate an image by a 90 degree angle\n");
  890.     printf("  -smooth               - smooth a color image\n");
  891.     printf("  -xzoom percentage     - zoom the X axis by a percentage\n");
  892. --- 38,55 ----
  893.     printf("Image_options:\n");
  894.     printf("  -at X,Y               - load image at location\n");
  895.     printf("  -background colorname - background color for bitmap images\n");
  896.     printf("                        - typical display needs 2.0 - 2.5\n");
  897.     printf("  -brighten percentage  - specify brightness multiplier\n");
  898.     printf("  -center               - center image\n");
  899.     printf("  -clip X,Y,W,H         - use clipped portion of image\n");
  900. +   printf("  -colors number        - specify maximum number of RGB colors\n");
  901.     printf("  -dither               - dither color image to bitmap image\n");
  902.     printf("  -foreground colorname - foreground color for bitmap images\n");
  903. +   printf("  -gamma display_gamma  - specify display gamma - default = 1.0\n");
  904. +   printf("  -gray                 - convert to grayscale (also -grey)\n");
  905.     printf("  -halftone             - halftone a color image to bitmap image\n");
  906.     printf("  -name name            - force next argument to be image name\n");
  907. +   printf("  -normalize            - convert image to normalized b & w\n");
  908.     printf("  -rotate degrees       - rotate an image by a 90 degree angle\n");
  909.     printf("  -smooth               - smooth a color image\n");
  910.     printf("  -xzoom percentage     - zoom the X axis by a percentage\n");
  911. ***************
  912. *** 122,127 ****
  913. --- 126,137 ----
  914.       freeImage(image);
  915.       image= tmpimage;
  916.     }
  917. + 
  918. +   if (options->gray) /* convert image to grayscale */
  919. +     gray(image, verbose);
  920. + 
  921. +   if (options->normalize) /* normalize image */
  922. +     normalize(image, verbose);
  923.   
  924.     if (options->bright) /* alter image brightness */
  925.       brighten(image, options->bright, verbose);
  926. diff -c src.2.01/mit.cpyrght src.2.02/mit.cpyrght
  927. *** src.2.01/mit.cpyrght    Sun Sep 30 19:04:13 1990
  928. --- src.2.02/mit.cpyrght    Sat Dec  1 14:26:50 1990
  929. ***************
  930. *** 20,26 ****
  931. --- 20,28 ----
  932.    * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  933.    */
  934.   
  935. + #ifndef __SABER__
  936.   static char *MitCopyright=
  937.     "Copyright 1989 Massachusetts Institute of Technology";
  938. + #endif
  939.   #define _MIT_COPYRIGHT_
  940.   #endif
  941. diff -c src.2.01/mrmcpyrght.h src.2.02/mrmcpyrght.h
  942. *** src.2.01/mrmcpyrght.h    Sun Sep 30 19:04:13 1990
  943. --- src.2.02/mrmcpyrght.h    Sat Dec  1 14:27:52 1990
  944. ***************
  945. *** 21,26 ****
  946. --- 21,28 ----
  947.     CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  948.   ****/
  949.   
  950. + #ifndef __SABER__
  951.   static char *MRMCopyright = "Copyright 1990 Mark Majhor";
  952. + #endif
  953.   #define _MRM_COPYRIGHT_
  954.   #endif
  955. diff -c src.2.01/new.c src.2.02/new.c
  956. *** src.2.01/new.c    Sun Sep 30 19:04:13 1990
  957. --- src.2.02/new.c    Sun Dec  2 12:29:54 1990
  958. ***************
  959. *** 28,33 ****
  960. --- 28,34 ----
  961.   {
  962.     rgb->used= 0;
  963.     rgb->size= size;
  964. +   rgb->compressed= 0;
  965.     rgb->red= (Intensity *)lmalloc(sizeof(Intensity) * size);
  966.     rgb->green= (Intensity *)lmalloc(sizeof(Intensity) * size);
  967.     rgb->blue= (Intensity *)lmalloc(sizeof(Intensity) * size);
  968. diff -c src.2.01/patchlevel src.2.02/patchlevel
  969. *** src.2.01/patchlevel    Sun Sep 30 19:04:30 1990
  970. --- src.2.02/patchlevel    Wed Oct  3 11:01:10 1990
  971. ***************
  972. *** 2,5 ****
  973.    */
  974.   
  975.   #define VERSION    "2"
  976. ! #define PATCHLEVEL "01"
  977. --- 2,5 ----
  978.    */
  979.   
  980.   #define VERSION    "2"
  981. ! #define PATCHLEVEL "02"
  982. diff -c src.2.01/reduce.c src.2.02/reduce.c
  983. *** src.2.01/reduce.c    Sun Sep 30 19:04:14 1990
  984. --- src.2.02/reduce.c    Sun Dec  2 12:29:25 1990
  985. ***************
  986. *** 175,180 ****
  987. --- 175,182 ----
  988.     lfree((byte *)dists);
  989.     lfree((byte *)same);
  990.   
  991. +   rgb->compressed= 0;
  992. + 
  993.     if (verbose)
  994.       printf("done\n");
  995.   }
  996. diff -c src.2.01/rle.c src.2.02/rle.c
  997. *** src.2.01/rle.c    Sun Sep 30 19:04:14 1990
  998. --- src.2.02/rle.c    Sat Dec  1 20:10:23 1990
  999. ***************
  1000. *** 37,43 ****
  1001.   static int y_min;        /* copy of picture y_min */
  1002.   
  1003.   /* option stuff (Not functional) */
  1004. ! static float disp_gam = 2.0;    /* default display gamma correction factor */
  1005.   static int gflag = 0;            /* if user supplies display gamma */
  1006.   static int iflag=0;            /* user suplied image gamma */
  1007.   static int lflag=0;            /* user supplied levels */
  1008. --- 37,43 ----
  1009.   static int y_min;        /* copy of picture y_min */
  1010.   
  1011.   /* option stuff (Not functional) */
  1012. ! static float disp_gam = 1.0;    /* default display gamma correction factor */
  1013.   static int gflag = 0;            /* if user supplies display gamma */
  1014.   static int iflag=0;            /* user suplied image gamma */
  1015.   static int lflag=0;            /* user supplied levels */
  1016. diff -c src.2.01/rle.h src.2.02/rle.h
  1017. *** src.2.01/rle.h    Sun Sep 30 19:04:14 1990
  1018. --- src.2.02/rle.h    Sun Dec  2 14:14:10 1990
  1019. ***************
  1020. *** 27,57 ****
  1021.    * 
  1022.    * Added optimised dither square size globals
  1023.    * 88/07/13 Graeme W. Gill
  1024. -  *
  1025. -  * $Header: svfb_global.h,v 2.7 86/11/10 11:25:18 thomas Exp $
  1026. -  * $Log:    svfb_global.h,v $
  1027. -  * Revision 2.7  86/11/10  11:25:18  thomas
  1028. -  * Add rle_get_setup return codes.
  1029. -  * Add is_seek flag to make pipe input work.
  1030. -  * 
  1031. -  * Revision 2.6  86/10/08  13:06:07  thomas
  1032. -  * Add sv_comments field.
  1033. -  * Add is_eof flag to Runget private data.
  1034. -  * 
  1035. -  * Revision 2.4  86/02/27  10:05:40  thomas
  1036. -  * Change for new sv_globals & sv_putrow interface.
  1037. -  * Add comments to data structure.
  1038. -  * 
  1039. -  * Revision 2.3  85/04/26  15:10:04  thomas
  1040. -  * New sv_globals structure.  sv_dispatch no longer global variable
  1041. -  * (incorporated into globals struct).
  1042. -  * 
  1043. -  * Revision 2.2  85/04/04  16:42:09  thomas
  1044. -  * Take out verbose flag, mapflag.  Add ncmap/cmaplen and map pointer.
  1045. -  * 
  1046. -  * Revision 2.1  85/03/05  16:02:03  thomas
  1047. -  * *** empty log message ***
  1048. -  * 
  1049.    */
  1050.   
  1051.   enum sv_dispatch {
  1052. --- 27,32 ----
  1053. ***************
  1054. *** 65,83 ****
  1055.    * pdp-11's (not sure if it's pdp11 or PDP11 ??)
  1056.    * are considered BIGENDIAN machines.
  1057.    */
  1058. - #if !defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  1059. - #if !defined(vax) && !defined(pdp11) && !defined(ns32000) && !defined(i386)
  1060. - #define BIG_ENDIAN
  1061. - #else
  1062. - #define LITTLE_ENDIAN
  1063. - #endif
  1064. - #endif
  1065.   
  1066. ! #ifdef BIG_ENDIAN
  1067. ! #define SWAB(shrt)  (shrt = ((shrt >> 8) & 0xff) | ((shrt << 8) & 0xff00))
  1068. ! #else
  1069. ! #define    SWAB(shrt)
  1070. ! #endif
  1071.   
  1072.   /* fix up some bezerklysims */
  1073.   #ifndef bzero
  1074. --- 40,47 ----
  1075.    * pdp-11's (not sure if it's pdp11 or PDP11 ??)
  1076.    * are considered BIGENDIAN machines.
  1077.    */
  1078.   
  1079. ! #define SWAB(val) (val= memToValLSB(&val, sizeof(val)))
  1080.   
  1081.   /* fix up some bezerklysims */
  1082.   #ifndef bzero
  1083. diff -c src.2.01/rlelib.c src.2.02/rlelib.c
  1084. *** src.2.01/rlelib.c    Sun Sep 30 19:04:32 1990
  1085. --- src.2.02/rlelib.c    Sun Dec  2 14:16:38 1990
  1086. ***************
  1087. *** 46,53 ****
  1088.    *         University of Utah
  1089.    * Date:    Mon Aug  9 1982
  1090.    * Copyright (c) 1982 Spencer W. Thomas
  1091. -  * 
  1092. -  * $Header: XtndRunsv.h,v 2.2 85/04/26 15:05:30 thomas Exp $
  1093.    */
  1094.   
  1095.   #ifndef XTNDRUNSV
  1096. --- 46,51 ----
  1097. ***************
  1098. *** 118,125 ****
  1099.    *         University of Utah
  1100.    * Date:    Mon Aug  9 1982
  1101.    * Copyright (c) 1982 Spencer W. Thomas
  1102. -  * 
  1103. -  * $Header: svfb.h,v 2.4 86/02/27 10:03:26 thomas Exp $
  1104.    */
  1105.   
  1106.   /* ****************************************************************
  1107. --- 116,121 ----
  1108. ***************
  1109. *** 197,215 ****
  1110.    *         University of Utah
  1111.    * Date:    Thu Apr 25 1985
  1112.    * Copyright (c) 1985,1986 Spencer W. Thomas
  1113. -  * 
  1114. -  * $Header: svfb_global.c,v 2.6 86/02/27 10:05:23 thomas Exp $
  1115. -  * $Log:    svfb_global.c,v $
  1116. -  * Revision 2.6  86/02/27  10:05:23  thomas
  1117. -  * Change for new sv_globals
  1118. -  * 
  1119. -  * Revision 2.5  86/02/25  17:32:18  thomas
  1120. -  * Take out misc.h
  1121. -  * 
  1122. -  * Revision 2.4  85/04/26  15:09:27  thomas
  1123. -  * Add header comment.  Change DTable to sv_DTable.  Changes for new
  1124. -  * sv_globals structure.
  1125. -  * 
  1126.    */
  1127.   
  1128.   
  1129. --- 193,198 ----
  1130. ***************
  1131. *** 296,307 ****
  1132.    *         University of Utah
  1133.    * Date:    Mon Aug  9 1982
  1134.    * Copyright (c) 1982,1986 Spencer W. Thomas
  1135. -  * 
  1136. -  * $Header: Runsv.c,v 2.9 86/02/27 10:01:13 thomas Locked $
  1137. -  * 
  1138. -  * Modified by:    Todd W. Fuqua
  1139. -  *     Date:    Jul 22 1984
  1140. -  * convert to new RLE format to make room for larger frame buffers
  1141.    */
  1142.   
  1143.   /* THIS IS WAY OUT OF DATE.  See rle.5.
  1144. --- 279,284 ----
  1145. ***************
  1146. *** 813,852 ****
  1147.    *         University of Utah
  1148.    * Date:    Wed Apr 10 1985
  1149.    * Copyright (c) 1985 Spencer W. Thomas
  1150. -  * 
  1151. -  * $Header: rle_getrow.c,v 1.12 86/11/10 12:30:34 thomas Exp $
  1152. -  * $Log:    rle_getrow.c,v $
  1153. -  * Revision 1.12  86/11/10  12:30:34  thomas
  1154. -  * NULL comments field if no comment in input file.
  1155. -  * 
  1156. -  * Revision 1.11  86/11/10  11:27:01  thomas
  1157. -  * Remove infile arguments.
  1158. -  * 
  1159. -  * Revision 1.10  86/11/10  11:19:04  thomas
  1160. -  * Fix to work with pipe input.
  1161. -  * 
  1162. -  * Revision 1.9  86/10/08  13:06:32  thomas
  1163. -  * Add header comments.
  1164. -  * Add EOF opcode.
  1165. -  * 
  1166. -  * Revision 1.6  86/02/27  10:05:55  thomas
  1167. -  * Change for new sv_globals interface.  Put "static" vars in structure.
  1168. -  * 
  1169. -  * Revision 1.5  86/02/25  17:32:28  thomas
  1170. -  * Add debugging.
  1171. -  * 
  1172. -  * Revision 1.4  86/02/11  11:38:09  thomas
  1173. -  * Oops: Only did clear to background right for ncolors = 3.
  1174. -  * Some lint fixes.
  1175. -  * 
  1176. -  * Revision 1.3  86/02/11  11:27:52  thomas
  1177. -  * Handle alpha channel.  Use bfill routine for efficiency.
  1178. -  * 
  1179. -  * Revision 1.2  85/05/22  15:09:23  thomas
  1180. -  * Swap magic number on BIGENDIAN machines.
  1181. -  * 
  1182. -  * Revision 1.1  85/05/22  12:36:21  thomas
  1183. -  * Initial revision
  1184.    * 
  1185.    */
  1186.   /*
  1187. --- 790,795 ----
  1188. diff -c src.2.01/root.c src.2.02/root.c
  1189. *** src.2.01/root.c    Sun Sep 30 19:04:14 1990
  1190. --- src.2.02/root.c    Sat Dec  1 16:21:13 1990
  1191. ***************
  1192. *** 14,20 ****
  1193.   #include "xloadimage.h"
  1194.   #include <X11/Xatom.h>
  1195.   
  1196. ! #define RETAIN_PROP_NAME    "XA_XLOADIMAGE_COLORS_XID"
  1197.   
  1198.   static void
  1199.   updateProperty(dpy, w, name, type, format, data, nelem)
  1200. --- 14,20 ----
  1201.   #include "xloadimage.h"
  1202.   #include <X11/Xatom.h>
  1203.   
  1204. ! #define RETAIN_PROP_NAME    "_XSETROOT_ID"
  1205.   
  1206.   static void
  1207.   updateProperty(dpy, w, name, type, format, data, nelem)
  1208. ***************
  1209. *** 134,140 ****
  1210.     freePrevious(disp, RootWindow(disp, scrn));
  1211.   
  1212.     if (! sendImageToX(disp, scrn, DefaultVisual(disp, scrn), image,
  1213. !              &pixmap, &xcmap, verbose))
  1214.       exit(1);
  1215.   
  1216.     /* changing the root colormap is A Bad Thing, so deny it.
  1217. --- 134,140 ----
  1218.     freePrevious(disp, RootWindow(disp, scrn));
  1219.   
  1220.     if (! sendImageToX(disp, scrn, DefaultVisual(disp, scrn), image,
  1221. !              &pixmap, &xcmap, 0, verbose))
  1222.       exit(1);
  1223.   
  1224.     /* changing the root colormap is A Bad Thing, so deny it.
  1225. diff -c src.2.01/send.c src.2.02/send.c
  1226. *** src.2.01/send.c    Sun Sep 30 19:04:14 1990
  1227. --- src.2.02/send.c    Sat Dec  1 20:27:02 1990
  1228. ***************
  1229. *** 11,17 ****
  1230.   #include "copyright.h"
  1231.   #include "xloadimage.h"
  1232.   
  1233. ! unsigned int sendImageToX(disp, scrn, visual, image, pixmap, cmap, verbose)
  1234.        Display      *disp;
  1235.        int           scrn;
  1236.        Visual       *visual;
  1237. --- 11,19 ----
  1238.   #include "copyright.h"
  1239.   #include "xloadimage.h"
  1240.   
  1241. ! unsigned int sendImageToX(disp, scrn, visual, image, pixmap, cmap,
  1242. !               private_cmap,
  1243. !               verbose)
  1244.        Display      *disp;
  1245.        int           scrn;
  1246.        Visual       *visual;
  1247. ***************
  1248. *** 18,23 ****
  1249. --- 20,26 ----
  1250.        Image        *image;
  1251.        Pixmap       *pixmap;
  1252.        Colormap     *cmap;
  1253. +      unsigned int  private_cmap;
  1254.        unsigned int  verbose;
  1255.   { Pixel        *index;
  1256.     unsigned int  a, b, newmap, x, y, linelen, ddepth, dpixlen;
  1257. ***************
  1258. *** 45,54 ****
  1259.     index= (Pixel *)lmalloc(sizeof(Pixel) * image->rgb.used);
  1260.     xcolor.flags= DoRed | DoGreen | DoBlue;
  1261.   
  1262. !   /* get the colormap to use
  1263.      */
  1264.   
  1265. !   if (visual == DefaultVisual(disp, scrn)) {
  1266.       *cmap= DefaultColormap(disp, scrn);
  1267.       newmap= 0;
  1268.   
  1269. --- 48,64 ----
  1270.     index= (Pixel *)lmalloc(sizeof(Pixel) * image->rgb.used);
  1271.     xcolor.flags= DoRed | DoGreen | DoBlue;
  1272.   
  1273. !   /* get the colormap to use.
  1274.      */
  1275.   
  1276. !   if (private_cmap) /* user asked us to use a private cmap */
  1277. !     newmap= 1;
  1278. ! 
  1279. !   /* if we're using the default visual, also use the default colormap
  1280. !    * so we share colors if possible.
  1281. !    */
  1282. ! 
  1283. !   else if (visual == DefaultVisual(disp, scrn)) {
  1284.       *cmap= DefaultColormap(disp, scrn);
  1285.       newmap= 0;
  1286.   
  1287. ***************
  1288. *** 70,79 ****
  1289.          * we had allocated and create a private colormap
  1290.          */
  1291.   
  1292. !       for (b= 0; b < a; b++)
  1293. !         XFreeColors(disp, *cmap, index + b, 1, 0);
  1294. !       *cmap= XCreateColormap(disp, RootWindow(disp, scrn), visual,
  1295. !                  AllocNone);
  1296.         newmap= 1;
  1297.         break;
  1298.       }
  1299. --- 80,86 ----
  1300.          * we had allocated and create a private colormap
  1301.          */
  1302.   
  1303. !       XFreeColors(disp, *cmap, index, a, 0);
  1304.         newmap= 1;
  1305.         break;
  1306.       }
  1307. ***************
  1308. *** 80,95 ****
  1309.         *(index + a)= xcolor.pixel;
  1310.       }
  1311.     }
  1312. !   else {
  1313.       if ((visual->class == PseudoColor) || (visual->class == GrayScale)) {
  1314.         *cmap= XCreateColormap(disp, RootWindow(disp, scrn), visual, AllocNone);
  1315.       }
  1316.       else
  1317.         *cmap= XCreateColormap(disp, RootWindow(disp, scrn), visual, AllocAll);
  1318. -     newmap= 1;
  1319. -   }
  1320. - 
  1321. -   if (newmap) {
  1322.       for (a= 0; a < image->rgb.used; a++) /* count entries we got */
  1323.         if (! XAllocColorCells(disp, *cmap, False, NULL, 0, index + a, 1))
  1324.       break;
  1325. --- 87,103 ----
  1326.         *(index + a)= xcolor.pixel;
  1327.       }
  1328.     }
  1329. !   else
  1330. !     newmap= 1;
  1331. ! 
  1332. !   if (newmap) {
  1333. !     if (verbose)
  1334. !       printf("  Using private colormap\n");
  1335.       if ((visual->class == PseudoColor) || (visual->class == GrayScale)) {
  1336.         *cmap= XCreateColormap(disp, RootWindow(disp, scrn), visual, AllocNone);
  1337.       }
  1338.       else
  1339.         *cmap= XCreateColormap(disp, RootWindow(disp, scrn), visual, AllocAll);
  1340.       for (a= 0; a < image->rgb.used; a++) /* count entries we got */
  1341.         if (! XAllocColorCells(disp, *cmap, False, NULL, 0, index + a, 1))
  1342.       break;
  1343. ***************
  1344. *** 140,149 ****
  1345.       }
  1346.       pixptr= image->data;
  1347.       modimageptr = image->data;
  1348. !     dpixlen = ddepth / 8;
  1349. !     if(image->pixlen != dpixlen) {  /* Need to convert depth */
  1350. !     modimageptr = (byte *)lmalloc(image->height * image->width * dpixlen);
  1351. !     }
  1352.       destptr = modimageptr;
  1353.       
  1354.       for (y= 0; y < image->height; y++)
  1355. --- 148,157 ----
  1356.       }
  1357.       pixptr= image->data;
  1358.       modimageptr = image->data;
  1359. !     dpixlen= (ddepth + 7) / 8;
  1360. !     if (image->pixlen != dpixlen) /* Need to convert depth */
  1361. !     modimageptr=
  1362. !       (byte *)lmalloc(image->height * image->width * dpixlen);
  1363.       destptr = modimageptr;
  1364.       
  1365.       for (y= 0; y < image->height; y++)
  1366. ***************
  1367. *** 180,186 ****
  1368.         ximage->byte_order= MSBFirst;
  1369.   
  1370.         for (plane= 1 << (ddepth - 1); plane; plane >>= 1) {
  1371. !     pixptr= image->data;
  1372.       destline= bitplane;
  1373.       for (y= 0; y < image->height; y++) {
  1374.         destmask= 0x80;
  1375. --- 188,194 ----
  1376.         ximage->byte_order= MSBFirst;
  1377.   
  1378.         for (plane= 1 << (ddepth - 1); plane; plane >>= 1) {
  1379. !     pixptr= modimageptr;
  1380.       destline= bitplane;
  1381.       for (y= 0; y < image->height; y++) {
  1382.         destmask= 0x80;
  1383. diff -c src.2.01/smooth.c src.2.02/smooth.c
  1384. *** src.2.01/smooth.c    Sun Sep 30 19:04:32 1990
  1385. --- src.2.02/smooth.c    Sun Dec  2 11:58:29 1990
  1386. ***************
  1387. *** 44,50 ****
  1388.       carray[a].pixel= a;
  1389.       carray[a].sum= rgb->red[a] + rgb->green[a] + rgb->blue[a];
  1390.     }
  1391. !   qsort(carray, rgb->used, sizeof(struct colorarray), colorPredicate);
  1392.     return(carray);
  1393.   }
  1394.   
  1395. --- 44,51 ----
  1396.       carray[a].pixel= a;
  1397.       carray[a].sum= rgb->red[a] + rgb->green[a] + rgb->blue[a];
  1398.     }
  1399. !   qsort((char *)carray, rgb->used, sizeof(struct colorarray),
  1400. !     colorPredicate);
  1401.     return(carray);
  1402.   }
  1403.   
  1404. diff -c src.2.01/value.c src.2.02/value.c
  1405. *** src.2.01/value.c    Sun Sep 30 19:04:15 1990
  1406. --- src.2.02/value.c    Sat Dec  1 13:57:20 1990
  1407. ***************
  1408. *** 13,19 ****
  1409.   #include "copyright.h"
  1410.   #include "image.h"
  1411.   
  1412. ! unsigned long memToVal(p, len)
  1413.        byte         *p;
  1414.        unsigned int  len;
  1415.   { unsigned int  a;
  1416. --- 13,19 ----
  1417.   #include "copyright.h"
  1418.   #include "image.h"
  1419.   
  1420. ! unsigned long doMemToVal(p, len)
  1421.        byte         *p;
  1422.        unsigned int  len;
  1423.   { unsigned int  a;
  1424. ***************
  1425. *** 25,31 ****
  1426.     return(i);
  1427.   }
  1428.   
  1429. ! void valToMem(val, p, len)
  1430.        unsigned long  val;
  1431.        byte          *p;
  1432.        unsigned int   len;
  1433. --- 25,31 ----
  1434.     return(i);
  1435.   }
  1436.   
  1437. ! unsigned long doValToMem(val, p, len)
  1438.        unsigned long  val;
  1439.        byte          *p;
  1440.        unsigned int   len;
  1441. ***************
  1442. *** 35,43 ****
  1443.       *(p + a)= val & 0xff;
  1444.       val >>= 8;
  1445.     }
  1446.   }
  1447.   
  1448. ! unsigned long memToValLSB(p, len)
  1449.        byte         *p;
  1450.        unsigned int  len;
  1451.   { int val, a;
  1452. --- 35,44 ----
  1453.       *(p + a)= val & 0xff;
  1454.       val >>= 8;
  1455.     }
  1456. +   return(val);
  1457.   }
  1458.   
  1459. ! unsigned long doMemToValLSB(p, len)
  1460.        byte         *p;
  1461.        unsigned int  len;
  1462.   { int val, a;
  1463. ***************
  1464. *** 51,57 ****
  1465.   /* this is provided for orthagonality
  1466.    */
  1467.   
  1468. ! void valToMemLSB(val, p, len)
  1469.        byte          *p;
  1470.        unsigned long  val;
  1471.        unsigned int   len;
  1472. --- 52,58 ----
  1473.   /* this is provided for orthagonality
  1474.    */
  1475.   
  1476. ! unsigned long doValToMemLSB(val, p, len)
  1477.        byte          *p;
  1478.        unsigned long  val;
  1479.        unsigned int   len;
  1480. ***************
  1481. *** 60,65 ****
  1482. --- 61,67 ----
  1483.       *(p++)= val & 0xff;
  1484.       val >>= 8;
  1485.     }
  1486. +   return(val);
  1487.   }
  1488.   
  1489.   /* this flips all the bits in a byte array at byte intervals
  1490. diff -c src.2.01/window.c src.2.02/window.c
  1491. *** src.2.01/window.c    Sun Sep 30 19:04:32 1990
  1492. --- src.2.02/window.c    Sat Dec  1 20:31:55 1990
  1493. ***************
  1494. *** 13,27 ****
  1495.   #include <ctype.h>
  1496.   #include <X11/cursorfont.h>
  1497.   
  1498. - #ifdef SYSV
  1499. - #include <string.h>
  1500. - #define index strchr
  1501. - #define rindex strrchr
  1502. - #else
  1503. - char *index();
  1504. - char *rindex();
  1505. - #endif
  1506. - 
  1507.   static Window ImageWindow= 0;
  1508.   
  1509.   static void setCursor(disp, window, iw, ih, ww, wh, cursor)
  1510. --- 13,18 ----
  1511. ***************
  1512. *** 154,160 ****
  1513.   }
  1514.   
  1515.   char imageInWindow(disp, scrn, image, user_geometry,
  1516. !            fullscreen, install, slideshow, argc, argv, verbose)
  1517.        Display      *disp;
  1518.        int           scrn;
  1519.        Image        *image;
  1520. --- 145,152 ----
  1521.   }
  1522.   
  1523.   char imageInWindow(disp, scrn, image, user_geometry,
  1524. !            fullscreen, install, private_cmap, slideshow,
  1525. !            argc, argv, verbose)
  1526.        Display      *disp;
  1527.        int           scrn;
  1528.        Image        *image;
  1529. ***************
  1530. *** 161,166 ****
  1531. --- 153,159 ----
  1532.        char         *user_geometry;
  1533.        unsigned int  fullscreen;
  1534.        unsigned int  install;
  1535. +      unsigned int  private_cmap;
  1536.        unsigned int  slideshow;
  1537.        int           argc;
  1538.        char         *argv[];
  1539. ***************
  1540. *** 221,227 ****
  1541.     }
  1542.   
  1543.     if (! sendImageToX(disp, scrn, DefaultVisual(disp, scrn),
  1544. !              image, &pixmap, &xcmap, verbose))
  1545.       exit(1);
  1546.   
  1547.     swa.background_pixel= BlackPixel(disp,scrn);
  1548. --- 214,220 ----
  1549.     }
  1550.   
  1551.     if (! sendImageToX(disp, scrn, DefaultVisual(disp, scrn),
  1552. !              image, &pixmap, &xcmap, private_cmap, verbose))
  1553.       exit(1);
  1554.   
  1555.     swa.background_pixel= BlackPixel(disp,scrn);
  1556. ***************
  1557. *** 241,247 ****
  1558.                      InputOutput, CopyFromParent,
  1559.                      CWBackPixel | CWBackingStore |
  1560.                      CWBitGravity | CWCursor | CWColormap |
  1561. !                    CWEventMask | CWSaveUnder, &swa);
  1562.       XSetCommand(disp, ImageWindow, argv, argc);
  1563.       classHint.res_class = "Xloadimage";
  1564.       classHint.res_name=NULL;
  1565. --- 234,241 ----
  1566.                      InputOutput, CopyFromParent,
  1567.                      CWBackPixel | CWBackingStore |
  1568.                      CWBitGravity | CWCursor | CWColormap |
  1569. !                    CWEventMask | CWSaveUnder |
  1570. !                    CWOverrideRedirect, &swa);
  1571.       XSetCommand(disp, ImageWindow, argv, argc);
  1572.       classHint.res_class = "Xloadimage";
  1573.       classHint.res_name=NULL;
  1574. ***************
  1575. *** 294,302 ****
  1576. --- 288,302 ----
  1577.     XMapWindow(disp, ImageWindow);
  1578.     placeImage(image->width, image->height, winwidth, winheight, &pixx, &pixy);
  1579.     if (paint) {
  1580. + #if 0
  1581. +     /* this will happen on ConfigureNotify; we avoid it here to keep from
  1582. +      * doing a double paint.
  1583. +      */
  1584. + 
  1585.       blitImage(disp, pixmap, ImageWindow, gc,
  1586.             pixx, pixy, image->width, image->height, winwidth, winheight,
  1587.             0, 0, winwidth, winheight);
  1588. + #endif
  1589.       XResizeWindow(disp, ImageWindow, winwidth, winheight);
  1590.       XChangeWindowAttributes(disp, ImageWindow, CWColormap, &swa);
  1591.     }
  1592. ***************
  1593. *** 393,404 ****
  1594.         setCursor(disp, ImageWindow, image->width, image->height,
  1595.           winwidth, winheight, &(swa.cursor));
  1596.   
  1597. !       /* repaint 
  1598.          */
  1599.   
  1600. !       blitImage(disp, pixmap, ImageWindow, gc,
  1601. !         pixx, pixy, image->width, image->height, winwidth, winheight,
  1602. !         0, 0, winwidth, winheight);
  1603.         break;
  1604.   
  1605.       case DestroyNotify:
  1606. --- 393,405 ----
  1607.         setCursor(disp, ImageWindow, image->width, image->height,
  1608.           winwidth, winheight, &(swa.cursor));
  1609.   
  1610. !       /* repaint if we just changed images
  1611.          */
  1612.   
  1613. !       if (paint)
  1614. !     blitImage(disp, pixmap, ImageWindow, gc,
  1615. !           pixx, pixy, image->width, image->height, winwidth, winheight,
  1616. !           0, 0, winwidth, winheight);
  1617.         break;
  1618.   
  1619.       case DestroyNotify:
  1620. diff -c src.2.01/xloadimage.c src.2.02/xloadimage.c
  1621. *** src.2.01/xloadimage.c    Sun Sep 30 19:04:33 1990
  1622. --- src.2.02/xloadimage.c    Sun Dec  2 13:17:06 1990
  1623. ***************
  1624. *** 1,4 ****
  1625. ! /* loadimage.c:
  1626.    *
  1627.    * generic image loader for X11
  1628.    *
  1629. --- 1,4 ----
  1630. ! /* xloadimage.c:
  1631.    *
  1632.    * generic image loader for X11
  1633.    *
  1634. ***************
  1635. *** 21,26 ****
  1636. --- 21,27 ----
  1637.   char *Options[] = {
  1638.     "onroot", /* global options */
  1639.     "border",
  1640. +   "default",
  1641.     "display",
  1642.     "fullscreen",
  1643.     "geometry",
  1644. ***************
  1645. *** 29,34 ****
  1646. --- 30,36 ----
  1647.     "list",
  1648.     "install",
  1649.     "path",
  1650. +   "private",
  1651.     "quiet",
  1652.     "slideshow",
  1653.     "supported",
  1654. ***************
  1655. *** 39,52 ****
  1656.     "at", /* image options */
  1657.     "background",
  1658.     "brighten",
  1659. -   "gamma",
  1660.     "center",
  1661.     "clip",
  1662.     "colors",
  1663.     "dither",
  1664.     "foreground",
  1665.     "halftone",
  1666.     "name",
  1667.     "rotate",
  1668.     "smooth",
  1669.     "xzoom",
  1670. --- 41,57 ----
  1671.     "at", /* image options */
  1672.     "background",
  1673.     "brighten",
  1674.     "center",
  1675.     "clip",
  1676.     "colors",
  1677.     "dither",
  1678.     "foreground",
  1679. +   "gamma",
  1680. +   "gray",
  1681. +   "grey",
  1682.     "halftone",
  1683.     "name",
  1684. +   "normalize",
  1685.     "rotate",
  1686.     "smooth",
  1687.     "xzoom",
  1688. ***************
  1689. *** 60,73 ****
  1690.     /* global options
  1691.      */
  1692.   
  1693. !   ONROOT= 0, BORDER, DISPLAY, FULLSCREEN, GEOMETRY, HELP, IDENTIFY, LIST,
  1694. !   INSTALL, PATH, QUIET, SLIDESHOW, SUPPORTED, VERBOSE, VER_NUM, VIEW,
  1695.   
  1696.     /* local options
  1697.      */
  1698.   
  1699. !   AT, BACKGROUND, BRIGHT, GAMMA, CENTER, CLIP, COLORS, DITHER, FOREGROUND,
  1700. !   HALFTONE, NAME, ROTATE, SMOOTH, XZOOM, YZOOM, ZOOM
  1701.   };
  1702.   
  1703.   /* if an image loader needs to have our display and screen, it will get
  1704. --- 65,80 ----
  1705.     /* global options
  1706.      */
  1707.   
  1708. !   ONROOT= 0, BORDER, DEFAULT, DISPLAY, FULLSCREEN, GEOMETRY, HELP,
  1709. !   IDENTIFY, LIST, INSTALL, PATH, PRIVATE, QUIET, SLIDESHOW, SUPPORTED,
  1710. !   VERBOSE, VER_NUM, VIEW,
  1711.   
  1712.     /* local options
  1713.      */
  1714.   
  1715. !   AT, BACKGROUND, BRIGHT, CENTER, CLIP, COLORS, DITHER, FOREGROUND,
  1716. !   GAMMA, GRAY, GREY, HALFTONE, NAME, NORMALIZE, ROTATE, SMOOTH,
  1717. !   XZOOM, YZOOM, ZOOM
  1718.   };
  1719.   
  1720.   /* if an image loader needs to have our display and screen, it will get
  1721. ***************
  1722. *** 78,83 ****
  1723. --- 85,100 ----
  1724.   Display *Disp= NULL;
  1725.   int      Scrn= 0;
  1726.   
  1727. + /* used for the -default option.  this is the root weave bitmap with
  1728. +  * the bits in the order that xloadimage likes.
  1729. +  */
  1730. + 
  1731. + #define root_weave_width 4
  1732. + #define root_weave_height 4
  1733. + static byte root_weave_bits[] = {
  1734. +   0xe0, 0xb0, 0xd0, 0x70
  1735. + };
  1736. + 
  1737.   /* the real thing
  1738.    */
  1739.   
  1740. ***************
  1741. *** 88,95 ****
  1742. --- 105,114 ----
  1743.     char         *dname;
  1744.     unsigned int  identify;
  1745.     unsigned int  install;
  1746. +   unsigned int  private_cmap;
  1747.     unsigned int  slideshow;
  1748.     unsigned int  verbose;
  1749. +   unsigned int  set_default;
  1750.     Image        *dispimage;      /* image that will be sent to the display */
  1751.     Image        *newimage;       /* new image we're loading */
  1752.     Display      *disp;           /* display we're sending to */
  1753. ***************
  1754. *** 104,109 ****
  1755. --- 123,129 ----
  1756.     unsigned int  slide_colors= 0; /* images when in -slideshow mode */
  1757.     unsigned int  slide_dither= 0;
  1758.     float         slide_gamma= 1.0;
  1759. +   unsigned int  slide_normalize= 0;
  1760.     unsigned int  slide_smooth= 0;
  1761.     unsigned int  slide_xzoom= 0;
  1762.     unsigned int  slide_yzoom= 0;
  1763. ***************
  1764. *** 131,136 ****
  1765. --- 151,158 ----
  1766.     fullscreen= 0;
  1767.     identify= 0;
  1768.     install= 0;
  1769. +   private_cmap= 0;
  1770. +   set_default= 0;
  1771.     slideshow= 0;
  1772.     user_geometry = NULL;
  1773.     winwidth= winheight= 0;
  1774. ***************
  1775. *** 140,145 ****
  1776. --- 162,168 ----
  1777.       images[a].name= NULL;
  1778.       images[a].atx= images[a].aty= 0;
  1779.       images[a].bright= 0;
  1780. +     images[a].normalize= 0;
  1781.       images[a].gamma= 1.0;
  1782.       images[a].center= 0;
  1783.       images[a].clipx= images[a].clipy= 0;
  1784. ***************
  1785. *** 165,170 ****
  1786. --- 188,194 ----
  1787.       images[imagecount++].name= argv[a];
  1788.       if (slideshow && (imagecount < MAXIMAGES)) {
  1789.         images[imagecount].bright= slide_bright;
  1790. +       images[imagecount].normalize= slide_normalize;
  1791.         images[imagecount].gamma= slide_gamma;
  1792.         images[imagecount].dither= slide_dither;
  1793.         images[imagecount].colors= slide_colors;
  1794. ***************
  1795. *** 192,197 ****
  1796. --- 216,225 ----
  1797.       border= argv[a];
  1798.         break;
  1799.   
  1800. +     case DEFAULT:
  1801. +       set_default= 1;
  1802. +       break;
  1803. + 
  1804.       case DISPLAY:
  1805.         if (argv[++a])
  1806.       dname= argv[a];
  1807. ***************
  1808. *** 226,231 ****
  1809. --- 254,263 ----
  1810.         showPath();
  1811.         break;
  1812.   
  1813. +     case PRIVATE:
  1814. +       private_cmap= 1;
  1815. +       break;
  1816. + 
  1817.       case QUIET:
  1818.         verbose= 0;
  1819.         break;
  1820. ***************
  1821. *** 270,275 ****
  1822. --- 302,313 ----
  1823.       images[imagecount].bg= argv[a];
  1824.         break;
  1825.   
  1826. +     case NORMALIZE:
  1827. +       images[imagecount].normalize= 1;
  1828. +       if (slideshow)
  1829. +     slide_normalize= images[imagecount].normalize;
  1830. +       break;
  1831. + 
  1832.       case BRIGHT:
  1833.         if (argv[++a]) {
  1834.       images[imagecount].bright= atoi(argv[a]);
  1835. ***************
  1836. *** 286,291 ****
  1837. --- 324,334 ----
  1838.         }
  1839.         break;
  1840.   
  1841. +     case GRAY:
  1842. +     case GREY:
  1843. +       images[imagecount].gray= 1;
  1844. +       break;
  1845. + 
  1846.       case CENTER:
  1847.         images[imagecount].center= 1;
  1848.         break;
  1849. ***************
  1850. *** 410,416 ****
  1851.       }
  1852.     }
  1853.   
  1854. !   if (!imagecount) /* NO-OP from here on */
  1855.       exit(0);
  1856.   
  1857.     if (identify) {                    /* identify the named image(s) */
  1858. --- 453,459 ----
  1859.       }
  1860.     }
  1861.   
  1862. !   if (!imagecount && !set_default) /* NO-OP from here on */
  1863.       exit(0);
  1864.   
  1865.     if (identify) {                    /* identify the named image(s) */
  1866. ***************
  1867. *** 439,444 ****
  1868. --- 482,504 ----
  1869.     Scrn= scrn= DefaultScreen(disp);
  1870.     XSetIOErrorHandler(ioErrorHandler);
  1871.   
  1872. +   /* handle -default option.  this resets the colormap and loads the
  1873. +    * default root weave.
  1874. +    */
  1875. + 
  1876. +   if (set_default) {
  1877. +     byte *old_data;
  1878. + 
  1879. +     dispimage= newBitImage(root_weave_width, root_weave_height);
  1880. +     old_data= dispimage->data;
  1881. +     dispimage->data= root_weave_bits;
  1882. +     imageOnRoot(disp, scrn, dispimage, 0);
  1883. +     dispimage->data= old_data;
  1884. +     freeImage(dispimage);
  1885. +     if (!imagecount) /* all done */
  1886. +       exit(0);
  1887. +   }
  1888. + 
  1889.     dispimage= NULL;
  1890.   
  1891.     if (onroot && (winwidth || winheight || images[0].center ||
  1892. ***************
  1893. *** 505,512 ****
  1894.         dispimage= newimage;
  1895.       if (slideshow) {
  1896.         switch(imageInWindow(disp, scrn, dispimage, user_geometry,
  1897. !                fullscreen, install, slideshow, argc, argv,
  1898. !                verbose)) {
  1899.         case '\0': /* window got nuked by someone */
  1900.       XCloseDisplay(disp);
  1901.       exit(1);
  1902. --- 565,572 ----
  1903.         dispimage= newimage;
  1904.       if (slideshow) {
  1905.         switch(imageInWindow(disp, scrn, dispimage, user_geometry,
  1906. !                fullscreen, install, private_cmap, slideshow,
  1907. !                argc, argv, verbose)) {
  1908.         case '\0': /* window got nuked by someone */
  1909.       XCloseDisplay(disp);
  1910.       exit(1);
  1911. ***************
  1912. *** 539,545 ****
  1913.     else {
  1914.       if (!slideshow)
  1915.         imageInWindow(disp, scrn, dispimage, user_geometry,
  1916. !             fullscreen, install, slideshow, argc, argv, verbose);
  1917.       cleanUpWindow(disp);
  1918.     }
  1919.     XCloseDisplay(disp);
  1920. --- 599,606 ----
  1921.     else {
  1922.       if (!slideshow)
  1923.         imageInWindow(disp, scrn, dispimage, user_geometry,
  1924. !             fullscreen, install, private_cmap, slideshow,
  1925. !             argc, argv, verbose);
  1926.       cleanUpWindow(disp);
  1927.     }
  1928.     XCloseDisplay(disp);
  1929. diff -c src.2.01/xloadimage.h src.2.02/xloadimage.h
  1930. *** src.2.01/xloadimage.h    Sun Sep 30 19:04:15 1990
  1931. --- src.2.02/xloadimage.h    Sun Dec  2 11:28:39 1990
  1932. ***************
  1933. *** 12,17 ****
  1934. --- 12,30 ----
  1935.   #include <X11/Xlib.h>
  1936.   #include <X11/Xutil.h>
  1937.   
  1938. + #ifdef SYSV
  1939. + #include <string.h>
  1940. + #ifndef index /* some SysV's do this for you */
  1941. + #define index strchr
  1942. + #endif
  1943. + #ifndef rindex
  1944. + #define rindex strrchr
  1945. + #endif
  1946. + #else
  1947. + char *index();
  1948. + char *rindex();
  1949. + #endif
  1950. + 
  1951.   #include "image.h"
  1952.   #include "options.h"
  1953.   
  1954. ***************
  1955. *** 27,36 ****
  1956. --- 40,53 ----
  1957.     unsigned int  clipx, clipy; /* area of image to be used */
  1958.     unsigned int  clipw, cliph;
  1959.     unsigned int  dither;       /* true if image is to be dithered */
  1960. +   unsigned int  equalize;     /* true if image is to be equalized */
  1961. +   unsigned int  gray;         /* true if image is to be grayed */
  1962. +   unsigned int  normalize;    /* true if image is to be normalized */
  1963.     unsigned int  colors;       /* max # of colors to use for this image */
  1964.     int           rotate;          /* # degrees to rotate image */
  1965.     unsigned int  smooth;       /* true if image is to be smoothed */
  1966.     char         *fg, *bg;      /* foreground/background colors if mono image */
  1967. +   unsigned int  force;        /* true if we should force alloc of new cmap */
  1968.     unsigned int  xzoom, yzoom; /* zoom percentages */
  1969.   } ImageOptions;
  1970.   
  1971. diff -c src.2.01/xloadimage.man src.2.02/xloadimage.man
  1972. *** src.2.01/xloadimage.man    Sun Sep 30 19:04:33 1990
  1973. --- src.2.02/xloadimage.man    Sun Dec  2 14:04:56 1990
  1974. ***************
  1975. *** 59,64 ****
  1976. --- 59,68 ----
  1977.   This sets the background portion of the window which is not covered by
  1978.   any images to be \fIcolor\fR.
  1979.   .TP
  1980. + -default
  1981. + Set the root background to the default root weave.  This is the same
  1982. + as \fIxsetroot\fR with no arguments.
  1983. + .TP
  1984.   -display \fIdisplay_name\fR
  1985.   X11 display name to send the image(s) to.
  1986.   .TP
  1987. ***************
  1988. *** 91,97 ****
  1989.   Load image(s) onto the root window instead of viewing in a window.
  1990.   This is the opposite of \fI-view\fR.  \fIXSetbg\fR has this option set
  1991.   by default.  Loading with the -onroot option will fail if enough
  1992. ! sharable colors cannot be allocated from the default colormap.
  1993.   .TP
  1994.   -path
  1995.   Displays the image path and image suffixes which will be used when
  1996. --- 95,103 ----
  1997.   Load image(s) onto the root window instead of viewing in a window.
  1998.   This is the opposite of \fI-view\fR.  \fIXSetbg\fR has this option set
  1999.   by default.  Loading with the -onroot option will fail if enough
  2000. ! sharable colors cannot be allocated from the default colormap.  The
  2001. ! Hewlett-Packard version 2 server will not work correctly with this
  2002. ! option if you are loading a color image.  See \fIBUGS\fR below.
  2003.   .TP
  2004.   -path
  2005.   Displays the image path and image suffixes which will be used when
  2006. ***************
  2007. *** 98,103 ****
  2008. --- 104,115 ----
  2009.   looking for images.  These are loaded from ~/.xloadimagerc and
  2010.   optionally from a systemwide file (normally /usr/lib/xloadimagerc).
  2011.   .TP
  2012. + -private
  2013. + Force the use of a private colormap.  Normally colors are allocated
  2014. + shared unless there are not enough colors available.  This option is
  2015. + always on for the Hewlett-Packard version 2 server due to a server
  2016. + bug.  This flag is ignored if used in conjuntion with -onroot.
  2017. + .TP
  2018.   -quiet
  2019.   Forces \fIxloadimage\fR and \fIxview\fR to be quiet.  This is the
  2020.   default for \fIxsetbg\fR, but the others like to whistle. 
  2021. ***************
  2022. *** 152,161 ****
  2023.   the first image, and the \fI-onroot\fR option is specified, the image
  2024.   will be centered on the display background. 
  2025.   .TP
  2026. - -colors \fIn\fR
  2027. - Specify the maximum number of colors to use in the image.  This is a
  2028. - way to forcibly reduce the depth of an image.
  2029. - .TP
  2030.   -clip \fIX\fR,\fIY\fR,\fIW\fR,\fIH\fR
  2031.   Clip the image before loading it.  \fIX\fR and \fIY\fR define the
  2032.   upper-left corner of the clip area, and \fIW\fR and \fIH\fR define the
  2033. --- 164,169 ----
  2034. ***************
  2035. *** 162,167 ****
  2036. --- 170,179 ----
  2037.   extents of the area.  A zero value for \fIW\fR or \fIH\fR will be
  2038.   interpreted as the remainder of the image. 
  2039.   .TP
  2040. + -colors \fIn\fR
  2041. + Specify the maximum number of colors to use in the image.  This is a
  2042. + way to forcibly reduce the depth of an image.
  2043. + .TP
  2044.   -dither
  2045.   Dither a color image to monochrome using a Floyd-Steinberg dithering
  2046.   algorithm.  This happens by default when viewing color images on a
  2047. ***************
  2048. *** 178,183 ****
  2049. --- 190,200 ----
  2050.   Specify the gamma correction for the display.
  2051.   The default value is 1.0, a typical display needs 2.0 to 2.5.
  2052.   .TP
  2053. + -gray
  2054. + Convert an image to grayscale.  This is very useful when displaying
  2055. + colorful images on servers with limited color capability.  The
  2056. + optional spelling \fI-grey\fR may also be used.
  2057. + .TP
  2058.   -halftone
  2059.   Force halftone dithering of a color image when displaying on a
  2060.   monochrome display.  This option is ignored on monochrome images.
  2061. ***************
  2062. *** 189,194 ****
  2063. --- 206,214 ----
  2064.   Force the next argument to be treated as an image name.  This is
  2065.   useful if the name of the image is \fI-dither\fR, for instance. 
  2066.   .TP
  2067. + -normalize
  2068. + Normalize a color image.
  2069. + .TP
  2070.   -rotate \fIdegrees\fR
  2071.   Rotate the image by \fIdegrees\fR clockwise.  The number must be a
  2072.   multiple of 90.
  2073. ***************
  2074. *** 260,270 ****
  2075.   change the aspect ratio of an image before display.  If you use these
  2076.   options, it is recommended that you increase the size of one of the
  2077.   dimensions instead of shrinking the other, since shrinking looses
  2078. ! detail.  For instance, many GIF images have an X:Y ratio of about 2:1.
  2079. ! You can correct this for viewing on a 1:1 display with either
  2080. ! \fI-xzoom 50\fR or \fI-yzoom 200\fR (reduce X axis to 50% of its size
  2081. ! and expand Y axis to 200% of its size, respectively) but the latter
  2082. ! should be used so no detail is lost in the conversion.
  2083.   .PP
  2084.   When zooming color images up you can reduce blockiness with
  2085.   \fI-smooth\fR.  For zooms of 300% or more, I recommend two smoothing
  2086. --- 280,290 ----
  2087.   change the aspect ratio of an image before display.  If you use these
  2088.   options, it is recommended that you increase the size of one of the
  2089.   dimensions instead of shrinking the other, since shrinking looses
  2090. ! detail.  For instance, many GIF and G3 FAX images have an X:Y ratio of
  2091. ! about 2:1.  You can correct this for viewing on a 1:1 display with
  2092. ! either \fI-xzoom 50\fR or \fI-yzoom 200\fR (reduce X axis to 50% of
  2093. ! its size and expand Y axis to 200% of its size, respectively) but the
  2094. ! latter should be used so no detail is lost in the conversion.
  2095.   .PP
  2096.   When zooming color images up you can reduce blockiness with
  2097.   \fI-smooth\fR.  For zooms of 300% or more, I recommend two smoothing
  2098. ***************
  2099. *** 307,312 ****
  2100. --- 327,335 ----
  2101.   white background (which is standard), use \fI-foreground white
  2102.   -background black\fR.  This will work on both color and monochrome
  2103.   displays.
  2104. + .PP
  2105. + If you're using a display with a small colormap to display colorful
  2106. + images, try using the \fI-gray\fR option to convert to grayscale.
  2107.   .SH PATHS AND EXTENSIONS
  2108.   The file ~/.xloadimagerc (and optionally a system-wide file) defines
  2109.   the path and default extensions that \fIxloadimage\fR will use when
  2110. ***************
  2111. *** 435,437 ****
  2112. --- 458,466 ----
  2113.   Wherever possible I tried to order operations in such a way as to look
  2114.   the best possible (zooming before dithering, for instance) or to
  2115.   increase speed (zooming downward before compressing, for instance).
  2116. + .PP
  2117. + The Hewlett-Packard release 2 server supplied with HP 9000/300
  2118. + machines has a bug in XAllocColor where an allocation will not work
  2119. + correctly for the default colormap.  To work around this,
  2120. + \fIxloadimage\fR forces the -private option on for this server.  This
  2121. + bug also results in the failure of -onroot for any color image.
  2122. diff -c src.2.01/xwd.c src.2.02/xwd.c
  2123. *** src.2.01/xwd.c    Sun Sep 30 19:04:34 1990
  2124. --- src.2.02/xwd.c    Thu Nov 15 17:08:53 1990
  2125. ***************
  2126. *** 176,184 ****
  2127.     xunits--; /* we want to use one less than the actual # of units */
  2128.     shift= (unit - trailer) * 8;
  2129.     if (header.byte_order == MSBFirst)
  2130. !     loader= memToVal;
  2131.     else
  2132. !     loader= memToValLSB;
  2133.     line= (byte *)lmalloc(dlinelen);
  2134.   
  2135.     for (y= 0; y < header.pixmap_height; y++) {
  2136. --- 176,184 ----
  2137.     xunits--; /* we want to use one less than the actual # of units */
  2138.     shift= (unit - trailer) * 8;
  2139.     if (header.byte_order == MSBFirst)
  2140. !     loader= doMemToVal;
  2141.     else
  2142. !     loader= doMemToValLSB;
  2143.     line= (byte *)lmalloc(dlinelen);
  2144.   
  2145.     for (y= 0; y < header.pixmap_height; y++) {
  2146. ***************
  2147. *** 253,261 ****
  2148.     xunits= (header.pixmap_width / (unit * 8)) +
  2149.       (header.pixmap_width % (unit * 8) ? 1 : 0);
  2150.     if (header.byte_order == MSBFirst)
  2151. !     loader= memToVal;
  2152.     else
  2153. !     loader= memToValLSB;
  2154.     line= (byte *)lmalloc(dlinelen);
  2155.   
  2156.     /* for each plane, load in the bitmap and or it into the image
  2157. --- 253,261 ----
  2158.     xunits= (header.pixmap_width / (unit * 8)) +
  2159.       (header.pixmap_width % (unit * 8) ? 1 : 0);
  2160.     if (header.byte_order == MSBFirst)
  2161. !     loader= doMemToVal;
  2162.     else
  2163. !     loader= doMemToValLSB;
  2164.     line= (byte *)lmalloc(dlinelen);
  2165.   
  2166.     /* for each plane, load in the bitmap and or it into the image
  2167. ***************
  2168. *** 342,350 ****
  2169.       dlinelen= depth * header.pixmap_width;
  2170.     ilinelen= image->width * image->pixlen;
  2171.     if (header.byte_order == MSBFirst)
  2172. !     loader= memToVal;
  2173.     else
  2174. !     loader= memToValLSB;
  2175.   
  2176.     line= (byte *)lmalloc(dlinelen);
  2177.   
  2178. --- 342,350 ----
  2179.       dlinelen= depth * header.pixmap_width;
  2180.     ilinelen= image->width * image->pixlen;
  2181.     if (header.byte_order == MSBFirst)
  2182. !     loader= doMemToVal;
  2183.     else
  2184. !     loader= doMemToValLSB;
  2185.   
  2186.     line= (byte *)lmalloc(dlinelen);
  2187.   
  2188. ***************
  2189. *** 488,496 ****
  2190.   
  2191.     image->rgb.used= header.ncolors;
  2192.     for (a= 0; a < header.ncolors; a++) {
  2193. !     image->rgb.red[a]= memToVal(cmap[a].red, 2);
  2194. !     image->rgb.green[a]= memToVal(cmap[a].green, 2);
  2195. !     image->rgb.blue[a]= memToVal(cmap[a].blue, 2);
  2196.     }
  2197.   
  2198.     lfree(cmap);
  2199. --- 488,496 ----
  2200.   
  2201.     image->rgb.used= header.ncolors;
  2202.     for (a= 0; a < header.ncolors; a++) {
  2203. !     image->rgb.red[memToVal(cmap[a].pixel, 4)]= memToVal(cmap[a].red, 2);
  2204. !     image->rgb.green[memToVal(cmap[a].pixel, 4)]= memToVal(cmap[a].green, 2);
  2205. !     image->rgb.blue[memToVal(cmap[a].pixel, 4)]= memToVal(cmap[a].blue, 2);
  2206.     }
  2207.   
  2208.     lfree(cmap);
  2209.  
  2210. --
  2211. dan
  2212. ----------------------------------------------------
  2213. O'Reilly && Associates   argv@sun.com / argv@ora.com
  2214. Opinions expressed reflect those of the author only.
  2215.